JvnCoordImpl.java

Go to the documentation of this file.

package jvn;

import java.rmi.Naming;
import java.rmi.RemoteException;
import java.rmi.server.UnicastRemoteObject;
import java.util.HashMap;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.concurrent.Semaphore;
import java.io.IOException;
import java.io.Serializable;

class JvnInvalidateReaderThread extends Thread
{
        private int objectID;

        private Semaphore semaphore;

        private JvnRemoteServer server;

        JvnInvalidateReaderThread( Semaphore sema, JvnRemoteServer serv, int joi )
        {
                server = serv;
                objectID = joi;
                semaphore = sema;
        }

        public void run() {
                try {
                        server.jvnInvalidateReader(objectID);
                } catch(JvnException e) {
                        System.out.println("Javanaise error while invalidating reader: " + e);
                }
                catch(RemoteException e) {
                        System.out.println("Network error while invalidating reader: " + e);
                }

                semaphore.release();
        }
}

class JvnServers {
        public JvnServers(JvnRemoteServer server, JvnObject obj) throws JvnException
        {
                jvnListOfServers.add(server);
                jvnObject = obj;
                if( obj!=null ) {
                        try {
                                latestJvnObjectContent = obj.jvnGetObjectState();
                        } catch( JvnException e ) {
                                latestJvnObjectContent = null;
                        }
                }
        }

        public LinkedList<JvnRemoteServer> jvnListOfServers = new LinkedList<JvnRemoteServer>();

        public JvnObject jvnObject = null;

        public JvnObjectState lockState = null;

        public Serializable latestJvnObjectContent = null;
}

public class JvnCoordImpl extends UnicastRemoteObject implements JvnRemoteCoord {
        private static final long serialVersionUID = -115305878534728396L;

        private int currID = -1;

        private static JvnCoordImpl jo = null;

        private HashMap<String,JvnServers> jvnServersOfNames = new HashMap<String, JvnServers>();

        private HashMap<Integer,JvnServers> jvnServersOfIdentifiers = new HashMap<Integer, JvnServers>();

        private JvnCoordImpl() throws Exception {
                Naming.rebind("AT_LD_jvnCoordinator", this);
                System.out.println("Javanaise Coordinator is ready.");
                currID = 0;
        }

        public static void main(String argv[]) throws Exception {
                if(jo==null){
                        jo = new JvnCoordImpl();
                        System.out.println("Press ENTER to terminate the Javanaise Coordinator.");
                        try {
                                System.in.read();
                        } catch (IOException e) {}
                }
        }

        public int jvnGetObjectId()
        throws java.rmi.RemoteException,jvn.JvnException {
                synchronized(this) {
                        return (++currID);
                }
        }

        public void jvnRegisterObject(String jon, JvnObject jo, JvnRemoteServer js)
        throws java.rmi.RemoteException,jvn.JvnException{
                // No one synchronizes on jvnServersOfNames,
                // synchronize on jvnServersOfIdentifiers
                synchronized(jvnServersOfIdentifiers) {

                        // Verify stuff
                        if( jo==null ) {
                                throw new JvnException("Invalid object!");
                        } else if( jo.jvnGetObjectId() < 0 ) {
                                throw new JvnException( "Invalid object ID! Please call jvnGetObjectId " +
                                                                                "to get a new object ID and associate it with the " +
                                                                                "Javanaise object using the jvnSetObjectId method." );
                        } else if( jvnServersOfIdentifiers.containsKey(jo.jvnGetObjectId()) ) {
                                throw new JvnException("Object with such an ID is already registered with this coordinator!");
                        } else if( jvnServersOfNames.containsKey(jon) ) {
                                throw new JvnException("Object with such a name is already registered with this coordinator!");
                        }

                        System.out.println("Registering object \""+jon+"\" (Object ID: "+jo.jvnGetObjectId()+")");

                        // All verifications are done, add to lists.
                        JvnServers servers = new JvnServers(js,jo);
                        servers.lockState = JvnObjectState.STATE_WLOCKT;
                        jvnServersOfNames.put(jon, servers);
                        jvnServersOfIdentifiers.put(jo.jvnGetObjectId(), servers);
                }
        }

        public JvnObject jvnLookupObject(String jon, Class<? extends JvnObject> type, JvnRemoteServer js)
        throws java.rmi.RemoteException,jvn.JvnException{
                // Verify arguments
                if( js==null ) {
                        throw new JvnException( "Invalid server! When calling this method " +
                                                                        "from a JvnRemoteServer, set the second "+
                                                                        "argument to \"this\".");
                }

                System.out.println("Looked up object: "+jon);

                // No one synchronizes on jvnServersOfNames,
                // synchronize on jvnServersOfIdentifiers
                synchronized(jvnServersOfIdentifiers) {
                        JvnServers servers = jvnServersOfNames.get(jon);
                        if( servers != null ) {
                                System.out.println("Found object with name \"" + jon + "\"");
                                return servers.jvnObject;
                        } else {
                                System.out.println("Not found object with name \"" + jon + "\"");
                                return null;
                        }
                }
        }

        public Serializable jvnLockRead(int joi, JvnRemoteServer js)
        throws java.rmi.RemoteException, JvnException{
                // Verify arguments
                if( js==null ) {
                        throw new JvnException( "Invalid server! When calling this method " +
                                                                        "from a JvnRemoteServer, set the second "+
                                                                        "argument to \"this\".");
                }

                synchronized(jvnServersOfIdentifiers)
                {
                        JvnServers servers = jvnServersOfIdentifiers.get(joi);
                        if( servers == null ) {
                                throw new JvnException( "The given object identifier is not registered" +
                                "with this coordinator!" );
                        } else if( servers.lockState == JvnObjectState.STATE_NOLOCK ) {
                                // No lock, just read lock and set the only reference
                                System.out.println("Read lock: getting lock (was not locked before).");
                                servers.lockState = JvnObjectState.STATE_RLOCKT;
                                servers.jvnListOfServers.clear();
                                servers.jvnListOfServers.add(js);
                        } else if( servers.lockState == JvnObjectState.STATE_RLOCKT ) {
                                // Read lock, just add a reference
                                System.out.println("Read lock: adding reference.");
                                servers.jvnListOfServers.add(js);
                        } else if( servers.lockState == JvnObjectState.STATE_WLOCKT ) {
                                try {
                                        System.out.println("Read lock: invalidating writer for reader.");
                                        JvnRemoteServer server = servers.jvnListOfServers.iterator().next();
                                        servers.latestJvnObjectContent = server.jvnInvalidateWriterForReader(joi);
                                        servers.lockState = JvnObjectState.STATE_RLOCKT;
                                        if( server.equals(js)) {
                                                System.out.println("Read lock: downgraded from write lock.");
                                        } else {
                                                System.out.println("Read lock: adding reference.");
                                                servers.jvnListOfServers.add(js);
                                        }
                                } catch( Exception e ) {
                                        // This will catch all kinds of stuff, including null pointers
                                        throw new JvnException("Error getting the read lock!\n"+e);
                                }
                        } else {
                                throw new JvnException("Unexpected lock state: " + servers.lockState + " !\n");
                        }

                        return servers.latestJvnObjectContent;
                }
        }

        public Serializable jvnLockWrite(int joi, JvnRemoteServer js)
        throws java.rmi.RemoteException, JvnException{
                // Verify arguments
                if( js==null ) {
                        throw new JvnException( "Invalid server! When calling this method " +
                                                                        "from a JvnRemoteServer, set the second "+
                                                                        "argument to \"this\".");
                }

                synchronized(jvnServersOfIdentifiers)
                {
                        JvnServers servers = jvnServersOfIdentifiers.get(joi);
                        if( servers == null ) {
                                throw new JvnException( "The given object identifier is not registered" +
                                                                                "with this coordinator!" );
                        } else if( servers.lockState == JvnObjectState.STATE_NOLOCK ) {
                                // No lock, just read lock
                                System.out.println("Write lock: getting lock (was not locked before).");
                                servers.lockState = JvnObjectState.STATE_WLOCKT;
                        } else if( servers.lockState == JvnObjectState.STATE_RLOCKT ) {
                                System.out.println("Write lock: invalidating readers.");
                                // Get back the read lock from all servers
                                int numberOfReaders = 0;
                                Semaphore s = new Semaphore(0);

                                Iterator<JvnRemoteServer> i = servers.jvnListOfServers.iterator();
                                while(i.hasNext()) {
                                        numberOfReaders++;
                                        (new JvnInvalidateReaderThread(s,i.next(),joi)).start();
                                }

                                // Wait for all threads to end
                                if( numberOfReaders>0 ) {
                                        try {
                                                s.acquire(numberOfReaders);
                                        } catch (InterruptedException e) {}
                                }
                                System.out.println("Write lock: invalidated "+numberOfReaders+" readers.");
                        } else if( servers.lockState == JvnObjectState.STATE_WLOCKT ) {
                                try {
                                        // Write-locked, request object
                                        System.out.println("Write lock: invalidating writer.");
                                        servers.latestJvnObjectContent = servers.jvnListOfServers.iterator().next().jvnInvalidateWriter(joi);
                                        System.out.println("Write lock: invalidated writer.");
                                } catch( Exception e ) {
                                        throw new JvnException("Error getting the write lock!\n"+e);
                                }
                        } else {
                                throw new JvnException("Unexpected lock state: "+servers.lockState+" !\n");
                        }

                        servers.jvnListOfServers.clear();
                        servers.jvnListOfServers.add(js);
                        servers.lockState = JvnObjectState.STATE_WLOCKT;

                        return servers.latestJvnObjectContent;
                }
        }

        public void jvnServerTerminated(JvnRemoteServer js) throws RemoteException, JvnException {
                // All verifications are done, add to lists.
                // No one synchronizes on jvnServersOfNames,
                // synchronize on jvnServersOfIdentifiers
                System.out.println("A server has terminated: unregistering.");

                synchronized(jvnServersOfIdentifiers) {
                        Iterator<JvnServers> i = jvnServersOfIdentifiers.values().iterator();
                        Iterator<JvnRemoteServer> j = null;
                        JvnRemoteServer server = null;
                        JvnServers servers = null;

                        // Loop on the list of registered objects
                        while(i.hasNext()) {
                                servers = i.next();
                                j = servers.jvnListOfServers.iterator();

                                // Loop on the list of servers
                                while(j.hasNext()) {
                                        server = j.next();

                                        // Server found! Invalidate...
                                        if(server.equals(js)) {
                                                if(servers.lockState == JvnObjectState.STATE_WLOCKT) {
                                                        System.out.println("A server has terminated: invalidating writer.");
                                                        servers.latestJvnObjectContent = servers.jvnObject.jvnInvalidateWriter();
                                                }
                                                servers.jvnListOfServers.remove(server);
                                                if(servers.jvnListOfServers.isEmpty()) {
                                                        servers.lockState = JvnObjectState.STATE_NOLOCK;
                                                }
                                                break;
                                        }
                                }
                        }
                }
                System.out.println("A server has terminated: unregister complete.");
        }
}

---